package mq

import (
	"encoding/json"
	"errors"
	"fmt"
	"gitee.com/daka1004/devops-runner/common/logs"
	"github.com/gorilla/websocket"
	"sync"
)

//
//import (
//	"encoding/json"
//	"errors"
//	"fmt"
//	"github.com/gorilla/websocket"
//	"sync"
//)
//
//// WebSocket连接管理器
//type WebSocketManager struct {
//	conn     *websocket.Conn
//	url      string
//	isClosed bool
//	mu       sync.Mutex
//}
//
//// NewWebSocketManager 创建新的WebSocket管理器
//func NewWebSocketManager2(url string) (*WebSocketManager, error) {
//	// 初始化连接
//	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
//	if err != nil {
//		return nil, fmt.Errorf("连接WebSocket失败: %v", err)
//	}
//
//	return &WebSocketManager{
//		conn:     conn,
//		url:      url,
//		isClosed: false,
//		mu:       sync.Mutex{},
//	}, nil
//}
//
//// Close 安全关闭WebSocket连接
//func (m *WebSocketManager) Close() error {
//	m.mu.Lock()
//	defer m.mu.Unlock()
//
//	if m.isClosed {
//		return nil
//	}
//
//	if m.conn != nil {
//		err := m.conn.Close()
//		m.conn = nil // 确保标记为nil
//		m.isClosed = true
//		return err
//	}
//
//	m.isClosed = true
//	return nil
//}
//
//// LogMessage 定义消息结构体
//type LogMessage struct {
//	Type    string `json:"type"`
//	Content string `json:"content"`
//}
//
//// 发送消息
//func (m *WebSocketManager) SendMessage(logLine, msgType string) error {
//	// 防御性检查：确保实例不为nil
//	/*	if m == nil {
//		return errors.New("WebSocketManager实例为nil")
//	}*/
//	m.mu.Lock()
//	defer m.mu.Unlock()
//
//	if m.isClosed {
//		return errors.New("WebSocket已关闭")
//	}
//
//	msg := LogMessage{Type: msgType, Content: logLine}
//	jsonData, err := json.Marshal(msg)
//	if err != nil {
//		return fmt.Errorf("序列化失败: %v", err)
//	}
//
//	return m.conn.WriteMessage(websocket.TextMessage, jsonData)
//}
// LogMessage 定义消息结构体
type LogMessage struct {
	Type    string `json:"type"`
	Content string `json:"content"`
}

type WebSocketLogger struct {
	conn       *websocket.Conn
	url        string
	isClosed   bool
	mu         sync.Mutex
	logChannel chan LogMessage
	done       chan struct{}
	err        error
}

// NewWebSocketLogger 创建一个新的WebSocket日志记录器
func NewWebSocketLogger(url string) *WebSocketLogger {
	return &WebSocketLogger{
		url:        url,
		logChannel: make(chan LogMessage, 100), // 缓冲通道，避免阻塞
		done:       make(chan struct{}),
	}
}

// Start 启动WebSocket连接和日志处理协程
func (l *WebSocketLogger) Start() error {
	l.mu.Lock()
	defer l.mu.Unlock()

	if l.isClosed {
		return errors.New("WebSocket连接已关闭")
	}

	if l.conn != nil {
		return nil // 连接已存在
	}

	// 建立WebSocket连接
	fmt.Println("建立WebSocket连接")
	conn, _, err := websocket.DefaultDialer.Dial(l.url, nil)
	if err != nil {
		l.err = fmt.Errorf("连接WebSocket服务器失败: %v", err)
		return l.err
	}

	l.conn = conn
	l.err = nil

	// 启动日志处理协程
	go l.processLogMessages()

	return nil
}

// Send 发送日志消息到WebSocket
func (l *WebSocketLogger) Send(logLine, msgType string) error {
	l.mu.Lock()
	defer l.mu.Unlock()

	if l.isClosed {
		return errors.New("WebSocket连接已关闭")
	}

	if l.err != nil {
		return l.err
	}

	// 发送日志到通道，由处理协程负责实际发送
	l.logChannel <- LogMessage{
		Type:    msgType,
		Content: logLine,
	}

	return nil
}

// processLogMessages 处理日志消息通道
func (l *WebSocketLogger) processLogMessages() {
	for {
		select {
		case msg, ok := <-l.logChannel:
			if !ok {
				return // 通道已关闭
			}

			jsonData, err := json.Marshal(msg)
			if err != nil {
				logs.Errorf("序列化日志消息失败: %v", err)
				continue
			}

			// 发送消息
			if err := l.conn.WriteMessage(websocket.TextMessage, jsonData); err != nil {
				l.mu.Lock()
				l.err = fmt.Errorf("发送日志到WebSocket服务器失败: %v", err)
				l.mu.Unlock()
				logs.Error(l.err)
			}
		case <-l.done:
			return
		}
	}
}

// Close 关闭WebSocket连接
func (l *WebSocketLogger) Close() error {
	l.mu.Lock()
	defer l.mu.Unlock()

	if l.isClosed || l.conn == nil {
		return nil
	}

	// 关闭通道，停止处理协程
	close(l.logChannel)
	close(l.done)

	// 关闭WebSocket连接
	fmt.Println("关闭WebSocket连接")
	if err := l.conn.Close(); err != nil {
		return err
	}

	l.isClosed = true
	l.conn = nil
	return nil
}
